<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>

                    <h4>单元测试</h4>
                    <div class="x-wiki-info"><span>564次阅读</span></div>
                    <hr style="border-top-color:#ccc" />
                    <div class="x-wiki-content x-content"><p>如果你听说过“测试驱动开发”（TDD：Test-Driven Development），单元测试就不陌生。</p>
<p>单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。</p>
<p>比如对函数<code>abs()</code>，我们可以编写出以下几个测试用例：</p>
<ol>
<li><p>输入正数，比如<code>1</code>、<code>1.2</code>、<code>0.99</code>，期待返回值与输入相同；</p>
</li>
<li><p>输入负数，比如<code>-1</code>、<code>-1.2</code>、<code>-0.99</code>，期待返回值与输入相反；</p>
</li>
<li><p>输入<code>0</code>，期待返回<code>0</code>；</p>
</li>
<li><p>输入非数值类型，比如<code>None</code>、<code>[]</code>、<code>{}</code>，期待抛出<code>TypeError</code>。</p>
</li>
</ol>
<p>把上面的测试用例放到一个测试模块里，就是一个完整的单元测试。</p>
<p>如果单元测试通过，说明我们测试的这个函数能够正常工作。如果单元测试不通过，要么函数有bug，要么测试条件输入不正确，总之，需要修复使单元测试能够通过。</p>
<p>单元测试通过后有什么意义呢？如果我们对<code>abs()</code>函数代码做了修改，只需要再跑一遍单元测试，如果通过，说明我们的修改不会对<code>abs()</code>函数原有的行为造成影响，如果测试不通过，说明我们的修改与原有行为不一致，要么修改代码，要么修改测试。</p>
<p>这种以测试为驱动的开发模式最大的好处就是确保一个程序模块的行为符合我们设计的测试用例。在将来修改的时候，可以极大程度地保证该模块行为仍然是正确的。</p>
<p>我们来编写一个<code>Dict</code>类，这个类的行为和<code>dict</code>一致，但是可以通过属性来访问，用起来就像下面这样：</p>
<pre><code>&gt;&gt;&gt; d = Dict(a=1, b=2)
&gt;&gt;&gt; d[&#39;a&#39;]
1
&gt;&gt;&gt; d.a
1
</code></pre><p><code>mydict.py</code>代码如下：</p>
<pre><code>class Dict(dict):

    def __init__(self, **kw):
        super(Dict, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r&quot;&#39;Dict&#39; object has no attribute &#39;%s&#39;&quot; % key)

    def __setattr__(self, key, value):
        self[key] = value
</code></pre><p>为了编写单元测试，我们需要引入Python自带的<code>unittest</code>模块，编写<code>mydict_test.py</code>如下：</p>
<pre><code>import unittest

from mydict import Dict

class TestDict(unittest.TestCase):

    def test_init(self):
        d = Dict(a=1, b=&#39;test&#39;)
        self.assertEquals(d.a, 1)
        self.assertEquals(d.b, &#39;test&#39;)
        self.assertTrue(isinstance(d, dict))

    def test_key(self):
        d = Dict()
        d[&#39;key&#39;] = &#39;value&#39;
        self.assertEquals(d.key, &#39;value&#39;)

    def test_attr(self):
        d = Dict()
        d.key = &#39;value&#39;
        self.assertTrue(&#39;key&#39; in d)
        self.assertEquals(d[&#39;key&#39;], &#39;value&#39;)

    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d[&#39;empty&#39;]

    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty
</code></pre><p>编写单元测试时，我们需要编写一个测试类，从<code>unittest.TestCase</code>继承。</p>
<p>以<code>test</code>开头的方法就是测试方法，不以<code>test</code>开头的方法不被认为是测试方法，测试的时候不会被执行。</p>
<p>对每一类测试都需要编写一个<code>test_xxx()</code>方法。由于<code>unittest.TestCase</code>提供了很多内置的条件判断，我们只需要调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是<code>assertEquals()</code>：</p>
<pre><code>self.assertEquals(abs(-1), 1) # 断言函数返回的结果与1相等
</code></pre><p>另一种重要的断言就是期待抛出指定类型的Error，比如通过<code>d[&#39;empty&#39;]</code>访问不存在的key时，断言会抛出<code>KeyError</code>：</p>
<pre><code>with self.assertRaises(KeyError):
    value = d[&#39;empty&#39;]
</code></pre><p>而通过<code>d.empty</code>访问不存在的key时，我们期待抛出<code>AttributeError</code>：</p>
<pre><code>with self.assertRaises(AttributeError):
    value = d.empty
</code></pre><h3 id="-">运行单元测试</h3>
<p>一旦编写好单元测试，我们就可以运行单元测试。最简单的运行方式是在<code>mydict_test.py</code>的最后加上两行代码：</p>
<pre><code>if __name__ == &#39;__main__&#39;:
    unittest.main()
</code></pre><p>这样就可以把<code>mydict_test.py</code>当做正常的python脚本运行：</p>
<pre><code>$ python mydict_test.py
</code></pre><p>另一种更常见的方法是在命令行通过参数<code>-m unittest</code>直接运行单元测试：</p>
<pre><code>$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s

OK
</code></pre><p>这是推荐的做法，因为这样可以一次批量运行很多单元测试，并且，有很多工具可以自动来运行这些单元测试。</p>
<h3 id="setup-teardown">setUp与tearDown</h3>
<p>可以在单元测试中编写两个特殊的<code>setUp()</code>和<code>tearDown()</code>方法。这两个方法会分别在每调用一个测试方法的前后分别被执行。</p>
<p><code>setUp()</code>和<code>tearDown()</code>方法有什么用呢？设想你的测试需要启动一个数据库，这时，就可以在<code>setUp()</code>方法中连接数据库，在<code>tearDown()</code>方法中关闭数据库，这样，不必在每个测试方法中重复相同的代码：</p>
<pre><code>class TestDict(unittest.TestCase):

    def setUp(self):
        print &#39;setUp...&#39;

    def tearDown(self):
        print &#39;tearDown...&#39;
</code></pre><p>可以再次运行测试看看每个测试方法调用前后是否会打印出<code>setUp...</code>和<code>tearDown...</code>。</p>
<h3 id="-">小结</h3>
<p>单元测试可以有效地测试某个程序模块的行为，是未来重构代码的信心保证。</p>
<p>单元测试的测试用例要覆盖常用的输入组合、边界条件和异常。</p>
<p>单元测试代码要非常简单，如果测试代码太复杂，那么测试代码本身就可能有bug。</p>
<p>单元测试通过了并不意味着程序就没有bug了，但是不通过程序肯定有bug。</p>
</div>

                    <hr style="border-top-color:#ccc" />

                    